home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / BBS-Archive / Comm / AmiTCP30b2.lha / src / util / portmap / portmap.c next >
C/C++ Source or Header  |  1994-05-03  |  12KB  |  498 lines
  1. RCS_ID_C="$Id: portmap.c,v 3.9 1994/05/02 19:52:55 jraja Exp $";
  2. /*
  3.  * portmap.c -- implements the program, version to port number mapping for rpc
  4.  */
  5.  
  6. #include "portmap_rev.h"
  7.  
  8. static const char version[] = VERSTAG
  9. " Copyright © 1994 AmiTCP/IP Group, <amitcp-group@hut.fi>\n"
  10. "Helsinki University of Technology, Finland.\n"
  11. "Copyright © 1990 The Regents of the University of California.\n"
  12. "All rights reserved.\n";
  13.  
  14. /****** netutil.doc/portmap *************************************************
  15.     NAME
  16.         portmap - DARPA port to RPC program number mapper
  17.  
  18.     SYNOPSIS
  19.         AmiTCP:bin/portmap
  20.  
  21.     DESCRIPTION
  22.         `portmap' is a server that converts RPC program numbers into DARPA
  23.         protocol port numbers.  It must be running in order to make RPC
  24.         calls.  When an RPC server is started, it will tell `portmap' what
  25.         port number it is listening to, and what RPC program numbers it is
  26.         prepared to serve.  When a client wishes to make an RPC call to a
  27.         given program number, it will first contact `portmap' on the
  28.         server machine to determine the port number where RPC packets
  29.         should be sent.  Normally, standard RPC servers are started by
  30.         `inetd', so `portmap' must be started before `inetd' is invoked.
  31.  
  32.     SEE ALSO
  33.         netutil.doc/rpcinfo
  34.  
  35.     BUGS
  36.         If `portmap' crashes, all servers must be restarted.
  37.  
  38. *****************************************************************************
  39. * 
  40. */
  41.  
  42. /*
  43.  * @(#)portmap.c 5.4 (Berkeley) 4/19/91
  44.  * @(#)portmap.c 2.3 88/08/11 4.0 RPCSRC
  45.  * @(#)portmap.c 1.32 87/08/06 Copyr 1984 Sun Micro";
  46.  */
  47.  
  48. #include <rpc/rpc.h>
  49. #include <rpc/pmap_prot.h>
  50. #include <sys/syslog.h>
  51. #include <sys/socket.h>
  52. #include <sys/ioctl.h>
  53. #include <netdb.h>
  54. #include <errno.h>
  55. #include <stdio.h>
  56. #include <stdlib.h>
  57. #include <string.h>
  58. #include <signal.h>
  59.  
  60. void reg_service(struct svc_req *rqstp, SVCXPRT *xprt);
  61. static void callit(struct svc_req *rqstp, SVCXPRT *xprt);
  62.  
  63. struct pmaplist *pmaplist;
  64. int debugging = 0;
  65.  
  66. main(int argc, char **argv)
  67. {
  68.     SVCXPRT *xprt;
  69.     int sock, c;
  70.     struct sockaddr_in addr = { 0 };
  71.     int len = sizeof(struct sockaddr_in);
  72.     register struct pmaplist *pml;
  73.  
  74.     signal(SIGINT, SIG_IGN); /* Prevent ANSI Signal handling */
  75.  
  76.     while ((c = getopt(argc, argv, "d")) != EOF) {
  77.         switch (c) {
  78.  
  79.         case 'd':
  80.             debugging = 1;
  81.             break;
  82.  
  83.         default:
  84.             (void) fprintf(stderr, "usage: %s [-d]\n", argv[0]);
  85.             exit(1);
  86.         }
  87.     }
  88.  
  89.     openlog("portmap", debugging ? LOG_PID | LOG_PERROR : LOG_PID,
  90.         LOG_DAEMON);
  91. #ifndef amigados
  92.     if (!debugging && daemon(0, 0)) {
  93.         (void) fprintf(stderr, "portmap: fork: %s", strerror(errno));
  94.         exit(1);
  95.     }
  96. #else
  97.     /*
  98.      * We could probably detach here, but don't bother now...
  99.      */
  100. #endif
  101.  
  102.     if ((sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
  103.         syslog(LOG_ERR, "cannot create udp socket: %m");
  104.         exit(1);
  105.     }
  106.  
  107.     addr.sin_addr.s_addr = 0;
  108.     addr.sin_family = AF_INET;
  109.     addr.sin_port = htons(PMAPPORT);
  110.     if (bind(sock, (struct sockaddr *)&addr, len) != 0) {
  111.         syslog(LOG_ERR, "cannot bind udp: %m");
  112.         exit(1);
  113.     }
  114.  
  115.     if ((xprt = svcudp_create(sock)) == (SVCXPRT *)NULL) {
  116.         syslog(LOG_ERR, "couldn't do udp_create");
  117.         exit(1);
  118.     }
  119.     /* make an entry for ourself */
  120.     pml = (struct pmaplist *)malloc((u_int)sizeof(struct pmaplist));
  121.     pml->pml_next = 0;
  122.     pml->pml_map.pm_prog = PMAPPROG;
  123.     pml->pml_map.pm_vers = PMAPVERS;
  124.     pml->pml_map.pm_prot = IPPROTO_UDP;
  125.     pml->pml_map.pm_port = PMAPPORT;
  126.     pmaplist = pml;
  127.  
  128.     if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  129.         syslog(LOG_ERR, "cannot create tcp socket: %m");
  130.         exit(1);
  131.     }
  132.     if (bind(sock, (struct sockaddr *)&addr, len) != 0) {
  133.         syslog(LOG_ERR, "cannot bind udp: %m");
  134.         exit(1);
  135.     }
  136.     if ((xprt = svctcp_create(sock, RPCSMALLMSGSIZE, RPCSMALLMSGSIZE))
  137.         == (SVCXPRT *)NULL) {
  138.         syslog(LOG_ERR, "couldn't do tcp_create");
  139.         exit(1);
  140.     }
  141.     /* make an entry for ourself */
  142.     pml = (struct pmaplist *)malloc((u_int)sizeof(struct pmaplist));
  143.     pml->pml_map.pm_prog = PMAPPROG;
  144.     pml->pml_map.pm_vers = PMAPVERS;
  145.     pml->pml_map.pm_prot = IPPROTO_TCP;
  146.     pml->pml_map.pm_port = PMAPPORT;
  147.     pml->pml_next = pmaplist;
  148.     pmaplist = pml;
  149.  
  150.     (void)svc_register(xprt, PMAPPROG, PMAPVERS, reg_service, FALSE);
  151.  
  152.     svc_run();
  153.     syslog(LOG_ERR, "svc_run returned unexpectedly");
  154.     exit(0);
  155. }
  156.  
  157. /*
  158.  * Overrides the strlib perror
  159.  */
  160. void
  161. perror(const char *what)
  162. {
  163.     syslog(LOG_ERR, "%s: %m", what);
  164. }
  165.  
  166. static struct pmaplist *
  167. find_service(u_long prog, u_long vers, u_long prot)
  168. {
  169.     register struct pmaplist *hit = NULL;
  170.     register struct pmaplist *pml;
  171.  
  172.     for (pml = pmaplist; pml != NULL; pml = pml->pml_next) {
  173.         if ((pml->pml_map.pm_prog != prog) ||
  174.             (pml->pml_map.pm_prot != prot))
  175.             continue;
  176.         hit = pml;
  177.         if (pml->pml_map.pm_vers == vers)
  178.             break;
  179.     }
  180.     return (hit);
  181. }
  182.  
  183. /* 
  184.  * 1 OK, 0 not
  185.  */
  186. void
  187. reg_service(struct svc_req *rqstp, SVCXPRT *xprt)
  188. {
  189.     struct pmap reg;
  190.     struct pmaplist *pml, *prevpml, *fnd;
  191.     int ans, port;
  192.     caddr_t t;
  193.     
  194.     if (debugging)
  195.         (void) fprintf(stderr, "server: about do a switch\n");
  196.     switch (rqstp->rq_proc) {
  197.  
  198.     case PMAPPROC_NULL:
  199.         /*
  200.          * Null proc call
  201.          */
  202.         if (!svc_sendreply(xprt, xdr_void, (caddr_t)0) && debugging) {
  203.             exit(20);
  204.         }
  205.         break;
  206.  
  207.     case PMAPPROC_SET:
  208.         /*
  209.          * Set a program,version to port mapping
  210.          */
  211.         if (!svc_getargs(xprt, xdr_pmap, ®))
  212.             svcerr_decode(xprt);
  213.         else {
  214.             /*
  215.              * check to see if already used
  216.              * find_service returns a hit even if
  217.              * the versions don't match, so check for it
  218.              */
  219.             fnd = find_service(reg.pm_prog, reg.pm_vers, reg.pm_prot);
  220.             if (fnd && fnd->pml_map.pm_vers == reg.pm_vers) {
  221.                 if (fnd->pml_map.pm_port == reg.pm_port) {
  222.                     ans = 1;
  223.                     goto done;
  224.                 }
  225.                 else {
  226.                     ans = 0;
  227.                     goto done;
  228.                 }
  229.             } else {
  230.                 /* 
  231.                  * add to END of list
  232.                  */
  233.                 pml = (struct pmaplist *)
  234.                     malloc((u_int)sizeof(struct pmaplist));
  235.                 pml->pml_map = reg;
  236.                 pml->pml_next = 0;
  237.                 if (pmaplist == 0) {
  238.                     pmaplist = pml;
  239.                 } else {
  240.                     for (fnd= pmaplist; fnd->pml_next != 0;
  241.                         fnd = fnd->pml_next);
  242.                     fnd->pml_next = pml;
  243.                 }
  244.                 ans = 1;
  245.             }
  246.         done:
  247.             if ((!svc_sendreply(xprt, xdr_long, (caddr_t)&ans)) &&
  248.                 debugging) {
  249.                 (void) fprintf(stderr, "svc_sendreply\n");
  250.                 exit(20);
  251.             }
  252.         }
  253.         break;
  254.  
  255.     case PMAPPROC_UNSET:
  256.         /*
  257.          * Remove a program,version to port mapping.
  258.          */
  259.         if (!svc_getargs(xprt, xdr_pmap, ®))
  260.             svcerr_decode(xprt);
  261.         else {
  262.             ans = 0;
  263.             for (prevpml = NULL, pml = pmaplist; pml != NULL; ) {
  264.                 if ((pml->pml_map.pm_prog != reg.pm_prog) ||
  265.                     (pml->pml_map.pm_vers != reg.pm_vers)) {
  266.                     /* both pml & prevpml move forwards */
  267.                     prevpml = pml;
  268.                     pml = pml->pml_next;
  269.                     continue;
  270.                 }
  271.                 /* found it; pml moves forward, prevpml stays */
  272.                 ans = 1;
  273.                 t = (caddr_t)pml;
  274.                 pml = pml->pml_next;
  275.                 if (prevpml == NULL)
  276.                     pmaplist = pml;
  277.                 else
  278.                     prevpml->pml_next = pml;
  279.                 free(t);
  280.             }
  281.             if ((!svc_sendreply(xprt, xdr_long, (caddr_t)&ans)) &&
  282.                 debugging) {
  283.                 (void) fprintf(stderr, "svc_sendreply\n");
  284.                 exit(20);
  285.             }
  286.         }
  287.         break;
  288.  
  289.     case PMAPPROC_GETPORT:
  290.         /*
  291.          * Lookup the mapping for a program,version and return its port
  292.          */
  293.         if (!svc_getargs(xprt, xdr_pmap, ®))
  294.             svcerr_decode(xprt);
  295.         else {
  296.             fnd = find_service(reg.pm_prog, reg.pm_vers, reg.pm_prot);
  297.             if (fnd)
  298.                 port = fnd->pml_map.pm_port;
  299.             else
  300.                 port = 0;
  301.             if ((!svc_sendreply(xprt, xdr_long, (caddr_t)&port)) &&
  302.                 debugging) {
  303.                 (void) fprintf(stderr, "svc_sendreply\n");
  304.                 exit(20);
  305.             }
  306.         }
  307.         break;
  308.  
  309.     case PMAPPROC_DUMP:
  310.         /*
  311.          * Return the current set of mapped program,version
  312.          */
  313.         if (!svc_getargs(xprt, xdr_void, NULL))
  314.             svcerr_decode(xprt);
  315.         else {
  316.             if ((!svc_sendreply(xprt, xdr_pmaplist,
  317.                 (caddr_t)&pmaplist)) && debugging) {
  318.                 (void) fprintf(stderr, "svc_sendreply\n");
  319.                 exit(20);
  320.             }
  321.         }
  322.         break;
  323.  
  324.     case PMAPPROC_CALLIT:
  325.         /*
  326.          * Calls a procedure on the local machine.  If the requested
  327.          * procedure is not registered this procedure does not return
  328.          * error information!!
  329.          * This procedure is only supported on rpc/udp and calls via 
  330.          * rpc/udp.  It passes null authentication parameters.
  331.          */
  332.         callit(rqstp, xprt);
  333.         break;
  334.  
  335.     default:
  336.         svcerr_noproc(xprt);
  337.         break;
  338.     }
  339. }
  340.  
  341.  
  342. /*
  343.  * Stuff for the rmtcall service
  344.  */
  345. #define ARGSIZE 9000
  346.  
  347. struct encap_parms {
  348.     u_int arglen;
  349.     char *args;
  350. };
  351.  
  352. static bool_t XDRFUN
  353. xdr_encap_parms(XDR *xdrs, struct encap_parms *epp)
  354. {
  355.  
  356.     return (xdr_bytes(xdrs, &(epp->args), &(epp->arglen), ARGSIZE));
  357. }
  358.  
  359. struct rmtcallargs {
  360.     u_long    rmt_prog;
  361.     u_long    rmt_vers;
  362.     u_long    rmt_port;
  363.     u_long    rmt_proc;
  364.     struct encap_parms rmt_args;
  365. };
  366.  
  367. static bool_t XDRFUN
  368. xdr_rmtcall_args(register XDR *xdrs, register struct rmtcallargs *cap)
  369. {
  370.  
  371.     /* does not get a port number */
  372.     if (xdr_u_long(xdrs, &(cap->rmt_prog)) &&
  373.         xdr_u_long(xdrs, &(cap->rmt_vers)) &&
  374.         xdr_u_long(xdrs, &(cap->rmt_proc))) {
  375.         return (xdr_encap_parms(xdrs, &(cap->rmt_args)));
  376.     }
  377.     return (FALSE);
  378. }
  379.  
  380. static bool_t XDRFUN
  381. xdr_rmtcall_result(register XDR *xdrs, register struct rmtcallargs *cap)
  382. {
  383.     if (xdr_u_long(xdrs, &(cap->rmt_port)))
  384.         return (xdr_encap_parms(xdrs, &(cap->rmt_args)));
  385.     return (FALSE);
  386. }
  387.  
  388. /*
  389.  * only worries about the struct encap_parms part of struct rmtcallargs.
  390.  * The arglen must already be set!!
  391.  */
  392. static bool_t XDRFUN
  393. xdr_opaque_parms(XDR *xdrs, struct rmtcallargs *cap)
  394. {
  395.  
  396.     return (xdr_opaque(xdrs, cap->rmt_args.args, cap->rmt_args.arglen));
  397. }
  398.  
  399. /*
  400.  * This routine finds and sets the length of incoming opaque parameters
  401.  * and then calls xdr_opaque_parms.
  402.  */
  403. static bool_t XDRFUN 
  404. xdr_len_opaque_parms(register XDR *xdrs, struct rmtcallargs *cap)
  405. {
  406.     register u_int beginpos, lowpos, highpos, currpos, pos;
  407.  
  408.     beginpos = lowpos = pos = xdr_getpos(xdrs);
  409.     highpos = lowpos + ARGSIZE;
  410.     while ((int)(highpos - lowpos) >= 0) {
  411.         currpos = (lowpos + highpos) / 2;
  412.         if (xdr_setpos(xdrs, currpos)) {
  413.             pos = currpos;
  414.             lowpos = currpos + 1;
  415.         } else {
  416.             highpos = currpos - 1;
  417.         }
  418.     }
  419.     xdr_setpos(xdrs, beginpos);
  420.     cap->rmt_args.arglen = pos - beginpos;
  421.     return (xdr_opaque_parms(xdrs, cap));
  422. }
  423.  
  424. /*
  425.  * Call a remote procedure service
  426.  * This procedure is very quiet when things go wrong.
  427.  * The proc is written to support broadcast rpc.  In the broadcast case,
  428.  * a machine should shut-up instead of complain, less the requestor be
  429.  * overrun with complaints at the expense of not hearing a valid reply ...
  430.  *
  431.  * This now forks so that the program & process that it calls can call 
  432.  * back to the portmapper.
  433.  */
  434. static void
  435. callit(struct svc_req *rqstp, SVCXPRT *xprt)
  436. {
  437.     struct rmtcallargs a;
  438.     struct pmaplist *pml;
  439.     u_short port;
  440.     struct sockaddr_in me;
  441. #ifndef amigados /* forking not supported */
  442.     int pid;
  443. #endif
  444.     int so = -1;
  445.     CLIENT *client;
  446.     struct authunix_parms *au = (struct authunix_parms *)rqstp->rq_clntcred;
  447.     struct timeval timeout;
  448.     char buf[ARGSIZE];
  449.  
  450.     timeout.tv_sec = 5;
  451.     timeout.tv_usec = 0;
  452.     a.rmt_args.args = buf;
  453.     if (!svc_getargs(xprt, xdr_rmtcall_args, &a))
  454.         return;
  455.     if ((pml = find_service(a.rmt_prog, a.rmt_vers,
  456.         (u_long)IPPROTO_UDP)) == NULL)
  457.         return;
  458. #ifndef amigados /* forking not supported */
  459.     /*
  460.      * fork a child to do the work.  Parent immediately returns.
  461.      * Child exits upon completion.
  462.      */
  463.     if ((pid = fork()) != 0) {
  464.         if (pid < 0)
  465.             syslog(LOG_ERR, "CALLIT (prog %lu): fork: %m",
  466.                 a.rmt_prog);
  467.         return;
  468.     }
  469. #endif
  470.     port = pml->pml_map.pm_port;
  471.     get_myaddress(&me);
  472.     me.sin_port = htons(port);
  473.     client = clntudp_create(&me, a.rmt_prog, a.rmt_vers, timeout, &so);
  474.     if (client != (CLIENT *)NULL) {
  475.         if (rqstp->rq_cred.oa_flavor == AUTH_UNIX) {
  476.             client->cl_auth = authunix_create(au->aup_machname,
  477.                au->aup_uid, au->aup_gid, au->aup_len, au->aup_gids);
  478.         }
  479.         a.rmt_port = (u_long)port;
  480.         if (clnt_call(client, a.rmt_proc, xdr_opaque_parms, &a,
  481.             xdr_len_opaque_parms, &a, timeout) == RPC_SUCCESS) {
  482.             svc_sendreply(xprt, xdr_rmtcall_result, (caddr_t)&a);
  483.         }
  484.         AUTH_DESTROY(client->cl_auth);
  485.         clnt_destroy(client);
  486.     }
  487.     (void)CloseSocket(so);
  488.     exit(0);
  489. }
  490.  
  491. #ifndef amigados /* forking not supported */
  492. void
  493. reap()
  494. {
  495.     while (wait3((int *)NULL, WNOHANG, (struct rusage *)NULL) > 0);
  496. }
  497. #endif
  498.